﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Drawing;
using System.Windows.Forms;
using GEAR_Structure;
namespace GraphicsStructure
{
        /// <summary>
        /// Disegna il grafico della stratigrafia dei componenti edilizi
        /// </summary>
        public class GraficComponent
        {
            Graphics grafico;
            Control superDis;
            /// <summary>
            /// superfice dove disegnare il grafico componente System.windows.form "Control"
            /// </summary>
            public Control SuperDis
            {
                get { return superDis; }
                set { superDis = value; }
            }
            DataTable dt_str;
            /// <summary>
            /// Datatable della stratigrafia
            /// </summary>
            public DataTable Dt_str
            {
                get { return dt_str; }
                set { dt_str = value; }
            }
            int mese = 0; //mese considerato per il profilo 0=gennaio ---11=dicembre
            /// <summary>
            /// mese considerato per il profilo 0=gennaio ---11=dicembre
            /// </summary>
            public int Mese
            {
                get { return mese; }
                set { mese = value; }
            }
            double[] profiloTemperature;//profilo temperature del singolo mese 
            /// <summary>
            /// vettore contenente il profilo delle temperature dall'esterno [0] all'interno [n]
            /// </summary>
            public double[] ProfiloTemperature
            {
                get { return profiloTemperature; }
                set { profiloTemperature = value; }
            }

            double[] profiloPressioniVS;
            /// <summary>
            /// vettore contente il profilo delle pressioni di vappore saturo dall'interno [0] all'esterno [n]
            /// </summary>
            public double[] ProfiloPressioniVS
            {
                get { return profiloPressioniVS; }
                set { profiloPressioniVS = value; }
            }
            double[] profiloPressioniV;
            public double[] ProfiloPressioniV
            {
                get { return profiloPressioniV; }
                set { profiloPressioniV = value; }
            }
            int tipoGrafico = 1;
            /// <summary>
            /// tipo grafico 1=temperature 2=pressioni vapore
            /// </summary>
            public int TipoGrafico
            {
                get { return tipoGrafico; }
                set { tipoGrafico = value; }
            }
            int bordoDx = 20;

            public int BordoDx
            {
                get { return bordoDx; }
                set { bordoDx = value; }
            }
            int didasc = 0;
            /// <summary>
            /// imposta la presenza o meno della didascalia del grafico 0=no 1=si
            /// </summary>
            public int Didasc
            {
                get { return didasc; }
                set { didasc = value; }
            }

            //string pathBMP = "bmp\\mat";
            ///// <summary>
            ///// imposta il percorso delle immagini del grafico per default "percorso aplicazione" + "/bmp/mat"
            ///// </summary>
            //public string PathBMP
            //{
            //    get { return pathBMP; }
            //    set { pathBMP = value; }
            //}

            Stratigraphy str;
            /// <summary>
            /// stratigrafia del componente
            /// </summary>
            public Stratigraphy Str
            {
                get { return str; }
                set { str = value; }
            }


            //costruttore
            public GraficComponent(Control _superDis, Stratigraphy _str)
            {
                this.superDis = _superDis;
                this.str = _str;
                this.grafico = this.superDis.CreateGraphics();
            }

            public GraficComponent(Control _superDis) : this(_superDis,null){}
      

            //Costruttore
            public GraficComponent()
            {
                //neccessario per derivazione
            }


            public void saveAsJpg(Stratigraphy s,string path,Size size)
            {
                Bitmap bmp = new Bitmap(size.Width,size.Height);
                Graphics g = Graphics.FromImage(bmp);
                Draw(g,s,new Rectangle(0,0,bmp.Width,bmp.Height),null,null,null);
                bmp.Save(path);
                bmp.Dispose();
            }

            public void saveAsJpg(string path,Size size)
            {
                saveAsJpg(this.str, path,size);
            }

            public void saveAsJpg(string path)
            {
                saveAsJpg(this.str, path, this.superDis.Size);
            }

            /// <summary>
            /// grafico
            /// </summary>
            /// <param name="SuperfDis">sup disegno (Pannel)</param>
            /// <param name="dt_str"></param>
            /// <param name="ProfiloTempertaure">profilo temp</param>
            /// <param name="ProfiloPressioniVS">profilo Pvs</param>
            /// <param name="ProfiloPressioniV">Profilo Pv</param>
            /// <param name="TipoGrafico">tipologia grafico Temperature=1 Vapore=2</param>
            /// <param name="BordoDx"></param>
            /// <param name="didasc"></param>
            //public void Grafico(Control SuperfDis, DataTable dt_str, double[] ProfiloTempertaure, double[] ProfiloPressioniVS, double[] ProfiloPressioniV, int TipoGrafico, int BordoDx, int didasc)
            public void Draw(Graphics g, Stratigraphy str, Rectangle rect, double[][] profiloTemperatureYear, double [][] profiloVapSatYear, double [][] profiloVapYear)
            {
                //this.Invalidate();
                /***************************************************************************************************************************    
                //tipo grafico 1=temperature 2=glaser
                ***************************************************************************************************************************/
                try
                {
                    //Dichiarazione Variabili Locali
                    //double[] ProfiloTempertaure = Condensa.ProfiloTempertaure;
                    //double[] ProfiloPressioniVS = Condensa.ProfiloPresVapSat;
                    //double[] ProfiloPressioniV = Condensa.ProfiloPresVap;


                    //disegno superficie bianca
                    g.FillRectangle(Brushes.White, rect);

                    Pen Linea = new Pen(Color.Black, 2);//Linea suddivisione interface
                    // Pen Linea1=new Pen(Color.Blue,1);


                    //variabili profilo temperature
                    int DT = 0;
                    Pen Lprof = new Pen(Color.Red, 3);// Stile lineaa profilo temperature

                    //variabili Profilo pressioni di vapore
                    int DP = 0;
                    Pen LprofPvs = new Pen(Color.Blue, 3);//stile linea Pvs
                    Pen LprofPv = new Pen(Color.Green, 3);//sile linea Pv

                    //Variabili didascalia
                    Pen Ldidascalia = new Pen(Color.Red, 1);


                    //definisco il bordo del contenitore
                    if (didasc == 0)
                    {
                        bordoDx = 20;
                    }
                    if (didasc == 1)
                    {
                        bordoDx = 100;
                    }


                    /*******************************************************************************************************
                     * dichiaro e definisco le variabili legate a numero strati e spessore totale del grafico
                     * *************************************************************************************************/

                    int Gspes = rect.Width - BordoDx;//larghezza del grafico ----- 100 larghezza della didascalia dal bordo dx, 20 default

                    // int ns = dt_str.Rows.Count;//numero strati del''elemento disegnato
                    // int[,] si = new int[ns, 3];//matrice contente le carateristiche del singolo strato
                    // int i = 0;
                    /*
                    foreach (DataRow dr_spessori in dt_str.Rows)
                    {
                        si[i, 1] = Convert.ToInt32(dr_spessori["Spessore[mm]"].ToString());
                        si[i, 2] = Convert.ToInt32(dr_spessori["Tipo"].ToString());
                        i++;
                    }
                    */
                    int ns = str.Layers.Count;//numero strati del''elemento disegnato
                    int[,] si = new int[ns, 3];//matrice contente le carateristiche del singolo strato
                    int i = 0;
                    foreach (Materiale m in str.Layers)
                    {
                        si[i, 1] = (int)(m.Tickness * 100);
                        si[i, 2] = (int)m.Typology;
                        i++;

                    }


                    /*****************************************************************************************************
                     * Imposto array che contiene le immagini e lo riempio con i dati
                     *****************************************************************************************************/
                    Image[] material = new Image[si.GetLength(0)];
                    for (i = 0; i < si.GetLength(0); i++)
                    {
                        switch (si[i, 2])
                        {
                            case 1:
                                material[i] = GraphicsStructure.Resource.mat1;
                                break;
                            case 2:
                                material[i] = GraphicsStructure.Resource.mat2;
                                break;
                            case 3:
                                material[i] = GraphicsStructure.Resource.mat3;
                                break;
                            case 4:
                                material[i] = GraphicsStructure.Resource.mat4;
                                break;
                            case 5:
                                material[i] = GraphicsStructure.Resource.mat5;
                                break;
                            case 6:
                                material[i] = GraphicsStructure.Resource.mat6;
                                break;
                            default:
                                material[i] = GraphicsStructure.Resource.mat1;
                                break;
                        }
                    }

                    //calcolo lo spessore totale della parete
                    int Stot = 0;
                    for (i = 0; i < si.GetLength(0); i++)
                    {
                        Stot += si[i, 1];
                    }

                    if (profiloTemperatureYear != null)
                    {

                        double[] pt = new double[profiloTemperatureYear[mese].GetLength(0)];
                       for (i = 0; i < profiloTemperatureYear[mese].GetLength(0); i++)
                           pt[i]  = profiloTemperatureYear[mese][i];
                        
                       ProfiloTemperature = pt;
                    }

                    if (profiloVapSatYear !=null)
                    {

                        double[] pvs = new double[profiloVapSatYear[mese].GetLength(0)];
                        for (i = 0; i < profiloVapSatYear[mese].GetLength(0); i++)
                            pvs[i] = profiloVapSatYear[mese][i];

                        ProfiloPressioniVS = pvs;
                    }

                    if (profiloVapYear != null)
                    {

                        double[] pv = new double[profiloVapYear[mese].GetLength(0)];
                        for (i = 0; i < profiloVapYear[mese].GetLength(0); i++)
                            pv[i] = profiloVapYear[mese][i];

                        ProfiloPressioniV = pv;
                    }


                    if (profiloTemperature != null)
                    //if (Condensa.ProfiloTempertaure!=null)
                    {

                        DT = Convert.ToInt32((profiloTemperature[profiloTemperature.GetLength(0) - 1] - profiloTemperature[0]) * 100);//Delta Temperatura percentuale
                        //DT=Convert.ToInt32((Condensa.ProfiloTempertaure[Condensa.ProfiloTempertaure.GetLength(0)-1]-Condensa.ProfiloTempertaure[0])*100);

                    }


                    if (profiloPressioniVS != null)
                    //if (Condensa.ProfiloPresVapSat != null)
                    {

                        DP = Convert.ToInt32((profiloPressioniVS[profiloPressioniVS.GetLength(0) - 1]));//"Delta" Pressione massima da rapresentare
                        //DP=Convert.ToInt32((Condensa.ProfiloPresVapSat[Condensa.ProfiloPresVapSat.GetLength(0)-1]));
                    }


                    /**************************************************************************************************************************************
                     * Definizione delle coordinate dei punti per il disegno del grafico
                     * *********************************************************************************************************************************/


                    Point P1 = new Point(10, 10); //punto in alto della prima linea        
                    // Point P2 = new Point(10, 240);
                    Point P2 = new Point(10, rect.Height - 25); //punto in basso della  prima linea

                    //definisco le proprietà del testo per la numerazione degli strati
                    String[] numeroStr = new string[si.GetLength(0)];
                    Font drawfont = new Font("Arial", 12);
                    SolidBrush drawbrush = new SolidBrush(Color.Black);


                    g.DrawLine(Linea, P1, P2);//disegna le linee di sudivisione - prima linea

                    //definisco ulteriori variabili per la rapresentazione di tutti gli strati
                    int Sincr = 0, SincrR = 0;
                    int Vartemp = 0, Vartemp1 = 0;
                    int VarVap = 0, VarVap1 = 0;


                    for (i = 0; i < si.GetLength(0); i++)
                    {
                        SincrR = Sincr;
                        Sincr += Gspes * si[i, 1] / Stot;
                        //Rectangle mat = new Rectangle(10 + SincrR+1, 10, Sincr-SincrR-1, 230); //disegno le immagini
                        Rectangle mat = new Rectangle(10 + SincrR + 1, 10, Sincr - SincrR - 1, rect.Height - 35);//disegno il rettangolo che contiene l'immagine dello strato
                        //grafico.DrawRectangle(Linea1, mat);
                        g.DrawImage(material[i], mat);//disegno l'immagine che rapresenta la tipologia dello strato
                        Point P1s = new Point(10 + Sincr, 10);//punto in alto delle linee sucessive alla prima linea 
                        //Point P2s = new Point(10 + Sincr, 240);
                        Point P2s = new Point(10 + Sincr, rect.Height - 25);//punto in basso delle linee sucessive alla prima linea
                        //Point Ptext = new Point((Sincr+SincrR)/2, 245);
                        Point Ptext = new Point((Sincr + SincrR) / 2, rect.Height - 20);// coordinate testo di numerazione dello strato
                        g.DrawLine(Linea, P1s, P2s);//disegno le linee


                        //numero gli strati
                        numeroStr[i] = (i + 1).ToString();
                        g.DrawString(numeroStr[i], drawfont, drawbrush, Ptext);//disegno il testo




                    }

                    /***********************************************************************************************************************************
                     * Disegno i profili - >Temperatura - Pressioni 
                     * ********************************************************************************************************************************/




                    //int GVarT = 210;//intervallo di variazione del profilo di temperatura all'interno dell'area di disegno
                    int GVarT = rect.Height - 55;

                    if (TipoGrafico == 1)
                    {
                        if (profiloTemperature != null)
                        //if(Condensa.ProfiloTempertaure != null)
                        {
                            Sincr = 0;
                            SincrR = 0;
                            int distBord = 60;

                            if (didasc == 0)
                            {



                                for (i = 1; i <= si.GetLength(0); i++)
                                {

                                    SincrR = Sincr;
                                    Sincr += Gspes * si[i - 1, 1] / Stot;
                                    //profilo fra 20 e 230
                                    Vartemp1 = Vartemp;
                                    Vartemp += GVarT * (Convert.ToInt32((profiloTemperature[i] - profiloTemperature[i - 1]) * 100)) / DT;
                                    //Vartemp += GVarT * (Convert.ToInt32((Condensa.ProfiloTempertaure[i]-Condensa.ProfiloTempertaure[i-1])*100))/DT;
                                    // Point Pt1 = new Point(10 + SincrR, 230 - Vartemp1);
                                    Point Pt1 = new Point(10 + SincrR, rect.Height - 35 - Vartemp1);
                                    //Point Pt2 = new Point(10 + Sincr, 230 - Vartemp);
                                    Point Pt2 = new Point(10 + Sincr, rect.Height - 35 - Vartemp);
                                    g.DrawLine(Lprof, Pt1, Pt2);


                                }
                            }
                            else
                            {

                                //disegno la didascalia - prima linea
                                Point Pt3 = new Point(10 + Sincr, rect.Height - 35 - Vartemp);
                                Point Pt31 = new Point(rect.Width - distBord, rect.Height - 35 - Vartemp);
                                g.DrawLine(Ldidascalia, Pt3, Pt31);//prima linea in basso
                                //testo della didascalia
                                g.DrawString(profiloTemperature[0].ToString("N1") + "°C", drawfont, drawbrush, Pt31);//disegno il testo


                                for (i = 1; i <= si.GetLength(0); i++)
                                {

                                    SincrR = Sincr;
                                    Sincr += Gspes * si[i - 1, 1] / Stot;
                                    //profilo fra 20 e 230
                                    Vartemp1 = Vartemp;
                                    Vartemp += GVarT * (Convert.ToInt32((profiloTemperature[i] - profiloTemperature[i - 1]) * 100)) / DT;
                                    //Vartemp += GVarT * (Convert.ToInt32((Condensa.ProfiloTempertaure[i]-Condensa.ProfiloTempertaure[i-1])*100))/DT;
                                    // Point Pt1 = new Point(10 + SincrR, 230 - Vartemp1);
                                    Point Pt1 = new Point(10 + SincrR, rect.Height - 35 - Vartemp1);
                                    //Point Pt2 = new Point(10 + Sincr, 230 - Vartemp);
                                    Point Pt2 = new Point(10 + Sincr, rect.Height - 35 - Vartemp);
                                    g.DrawLine(Lprof, Pt1, Pt2);

                                    //disegno la didascalia
                                    Point Pt32 = new Point(rect.Width - distBord, rect.Height - 35 - Vartemp);//secondo punto della lineaa di didascalia
                                    g.DrawLine(Ldidascalia, Pt2, Pt32);

                                    //testo della didascalia
                                    g.DrawString(profiloTemperature[i].ToString("N1") + "°C", drawfont, drawbrush, Pt32);//disegno il testo
                                }



                            }
                        }
                    }
                    else
                    {
                        if (profiloPressioniVS != null)
                        //if (Condensa.ProfiloPresVapSat != null)
                        {
                            Sincr = 0;
                            SincrR = 0;
                            //in questo caso uso una scala assoluta per disegnare il profilo il cui valore massimo e la max Pvs
                            VarVap = GVarT * (Convert.ToInt32(profiloPressioniVS[0])) / DP;
                            //VarVap = GVarT * (Convert.ToInt32(Condensa.ProfiloPresVapSat[0])) / DP;
                            for (i = 1; i <= si.GetLength(0); i++)
                            {

                                SincrR = Sincr;
                                Sincr += Gspes * si[i - 1, 1] / Stot;
                                //profilo fra 20 e 230
                                VarVap1 = VarVap;
                                // VarVap += GVarT * (Convert.ToInt32((ProfiloPressioniVS[i] - ProfiloPressioniVS[i - 1]))) / DP;
                                VarVap = GVarT * (Convert.ToInt32(profiloPressioniVS[i])) / DP;
                                //VarVap=GVarT*(Convert.ToInt32(Condensa.ProfiloPresVapSat[i]))/DP;
                                // Point Pt1 = new Point(10 + SincrR, 230 - Vartemp1);
                                Point Pt1 = new Point(10 + SincrR, rect.Height - 35 - VarVap1);
                                //Point Pt2 = new Point(10 + Sincr, 230 - Vartemp);
                                Point Pt2 = new Point(10 + Sincr, rect.Height - 35 - VarVap);
                                g.DrawLine(LprofPvs, Pt1, Pt2);
                            }

                        }
                        //if (Condensa.ProfiloPresVap != null)
                        if (profiloPressioniV != null)
                        {
                            Sincr = 0;
                            SincrR = 0;

                            int distBord = 80;
                            /********************************************************************************************************
                             //in questo caso uso una scala assoluta per disegnare il profilo il qui valore massimo e la max Pvs
                             *******************************************************************************************************/
                            if (didasc == 0)
                            {
                                //VarVap = GVarT * (Convert.ToInt32(Condensa.ProfiloPresVap[0])) / DP;
                                VarVap = GVarT * (Convert.ToInt32(profiloPressioniV[0])) / DP;
                                for (i = 1; i <= si.GetLength(0); i++)
                                {

                                    SincrR = Sincr;
                                    Sincr += Gspes * si[i - 1, 1] / Stot;
                                    //profilo fra 20 e 230
                                    VarVap1 = VarVap;
                                    //VarVap = GVarT * (Convert.ToInt32(Condensa.ProfiloPresVap[i])) / DP;
                                    VarVap = GVarT * (Convert.ToInt32(profiloPressioniV[i])) / DP;
                                    // Point Pt1 = new Point(10 + SincrR, 230 - Vartemp1);
                                    Point Pt1 = new Point(10 + SincrR, rect.Height - 35 - VarVap1);
                                    //Point Pt2 = new Point(10 + Sincr, 230 - Vartemp);
                                    Point Pt2 = new Point(10 + Sincr, rect.Height - 35 - VarVap);
                                    g.DrawLine(LprofPv, Pt1, Pt2);

                                }
                            }
                            else
                            {
                                VarVap = GVarT * (Convert.ToInt32(profiloPressioniV[0])) / DP;
                                for (i = 1; i <= si.GetLength(0); i++)
                                {

                                    SincrR = Sincr;
                                    Sincr += Gspes * si[i - 1, 1] / Stot;
                                    //profilo fra 20 e 230
                                    VarVap1 = VarVap;
                                    //VarVap = GVarT * (Convert.ToInt32(Condensa.ProfiloPresVap[i])) / DP;
                                    VarVap = GVarT * (Convert.ToInt32(profiloPressioniV[i])) / DP;
                                    // Point Pt1 = new Point(10 + SincrR, 230 - Vartemp1);
                                    Point Pt1 = new Point(10 + SincrR, rect.Height - 35 - VarVap1);
                                    //Point Pt2 = new Point(10 + Sincr, 230 - Vartemp);
                                    Point Pt2 = new Point(10 + Sincr, rect.Height - 35 - VarVap);
                                    g.DrawLine(LprofPv, Pt1, Pt2);


                                    //disegno la didascalia
                                    Point Pt32 = new Point(rect.Width - distBord, rect.Height - 35 - VarVap);//secondo punto della lineaa di didascalia
                                    g.DrawLine(Ldidascalia, Pt2, Pt32);

                                    //testo della didascalia
                                    g.DrawString(profiloPressioniV[i].ToString("N") + "Pa", drawfont, drawbrush, Pt32);//disegno il testo
                                }

                            }


                            /******************************************************************************************************************************
                             * disegno della didascalia
                             * *******************************************************************************************************************************/



                        }
                    }
                    g.Dispose();
                }
                catch
                {
                    if (profiloTemperature == null && profiloPressioniV == null)
                    {
                        MessageBox.Show("Impostare Profilo Temperature o Profilo Pressioni Vapore", "Attenzione!", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
        }
    }
